<html>
<head><meta charset="utf-8"><title>lazy_normalization_consts · project-const-generics · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/index.html">project-const-generics</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html">lazy_normalization_consts</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="217328268"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217328268" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217328268">(Nov 19 2020 at 20:47)</a>:</h4>
<p>Now that <code>min_const_generics</code> is pretty much done i want to focus on <code>lazy_normalization_consts</code> next. The general issue described in <a href="https://github.com/rust-lang/rust/issues/78369#issuecomment-727898111">https://github.com/rust-lang/rust/issues/78369#issuecomment-727898111</a> makes me really uncomfortable so I am thinking of ways around that.</p>
<p>A way around this would be to rely on what we are doing with <code>const_evaluatable_checked</code>, or much rather, as consts can't depend on generic params yet, we could just yeet their substs into orbit during typeck and ignore them for now.</p>



<a name="217328447"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217328447" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217328447">(Nov 19 2020 at 20:49)</a>:</h4>
<p>all of this is also really weird so I want to spend a bit more time looking into this and experiment a bit here</p>



<a name="217329179"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217329179" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217329179">(Nov 19 2020 at 20:56)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> <span class="user-mention" data-user-id="121053">@varkor</span> are you, or someone else, interested in a sync meeting about this in around two weeks? Would try to prepare a bit before then</p>



<a name="217457694"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217457694" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217457694">(Nov 20 2020 at 20:57)</a>:</h4>
<p>Hmm, not next week, but maybe the week afterwards</p>



<a name="217457718"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217457718" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217457718">(Nov 20 2020 at 20:57)</a>:</h4>
<p>I haven't really had time to read into <a href="https://github.com/rust-lang/rust/issues/78369">#78369</a> though</p>



<a name="217671927"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/217671927" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#217671927">(Nov 23 2020 at 19:28)</a>:</h4>
<p>Similar situation with me. I've been trying to complete a project recently, so I haven't had much time to keep up these past couple of weeks.</p>



<a name="218274305"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218274305" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218274305">(Nov 30 2020 at 11:17)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> <span class="user-mention" data-user-id="121053">@varkor</span> <span class="user-mention" data-user-id="124288">@oli</span> does this friday work for you? maybe  <time datetime="2020-12-04T18:00:00Z">2020-12-04T19:00:00+01:00</time></p>



<a name="218274356"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218274356" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218274356">(Nov 30 2020 at 11:17)</a>:</h4>
<p>yes</p>



<a name="218289525"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218289525" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218289525">(Nov 30 2020 at 14:02)</a>:</h4>
<p>I will need to rearrange another meeting, but it should be doable.</p>



<a name="218496127"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218496127" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218496127">(Dec 01 2020 at 23:18)</a>:</h4>
<p>I could do that</p>



<a name="218496138"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218496138" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218496138">(Dec 01 2020 at 23:18)</a>:</h4>
<p>can someone send a calendar invite, though :)</p>



<a name="218497366"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218497366" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218497366">(Dec 01 2020 at 23:33)</a>:</h4>
<p>does that work?</p>
<p><a href="https://calendar.google.com/event?action=TEMPLATE&amp;tmeid=NWpvY3ZrdGM3OHFrOWE2MDBvZmI4NGxlaDcgYmFzdGlhbl9rYXVzY2hrZUBob3RtYWlsLmRl&amp;tmsrc=bastian_kauschke%40hotmail.de">link</a></p>



<a name="218497424"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218497424" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218497424">(Dec 01 2020 at 23:34)</a>:</h4>
<p>i don't really use google calendar myself</p>



<a name="218521866"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218521866" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218521866">(Dec 02 2020 at 07:18)</a>:</h4>
<p>"could not find the requested event"</p>



<a name="218527876"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218527876" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218527876">(Dec 02 2020 at 08:44)</a>:</h4>
<p><a href="https://calendar.google.com/event?action=TEMPLATE&amp;tmeid=NWpvY3ZrdGM3OHFrOWE2MDBvZmI4NGxlaDcgYmFzdGlhbl9rYXVzY2hrZUBob3RtYWlsLmRl&amp;tmsrc=bastian_kauschke%40hotmail.de">this one?</a></p>



<a name="218530997"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218530997" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218530997">(Dec 02 2020 at 09:17)</a>:</h4>
<p>same error</p>



<a name="218531047"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218531047" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218531047">(Dec 02 2020 at 09:17)</a>:</h4>
<p>can you add ppl to the participant list and let the calendar send out invites?</p>



<a name="218531219"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218531219" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218531219">(Dec 02 2020 at 09:19)</a>:</h4>
<p>yeah, i can add emails</p>



<a name="218551251"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218551251" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218551251">(Dec 02 2020 at 12:54)</a>:</h4>
<p>the minimal subset of lazy norm needed to fix the cycle errors. I am currently thinking about using this and scrapping full lazy norm, at least for now. This would be enough for `const_generics' afaict and does not have the issues plaguing full lazy norm <a href="https://github.com/lcnr/rust/pull/3">https://github.com/lcnr/rust/pull/3</a></p>
<p>In case someone wants to look at this before the meeting. It's fine if you don't do so as it is a fairly straightforward change</p>



<a name="218551320"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218551320" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218551320">(Dec 02 2020 at 12:55)</a>:</h4>
<p>where can I find your email adresses?</p>



<a name="218555080"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218555080" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218555080">(Dec 02 2020 at 13:27)</a>:</h4>
<p>not sure, let me PM you those I have</p>



<a name="218685545"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218685545" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218685545">(Dec 03 2020 at 12:19)</a>:</h4>
<p>Where will the meeting take place? Here on Zulip?</p>



<a name="218691528"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218691528" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218691528">(Dec 03 2020 at 13:22)</a>:</h4>
<p>hmm, i slightly prefer zoom though it doesn't really matter tbh</p>



<a name="218825075"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218825075" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218825075">(Dec 04 2020 at 12:16)</a>:</h4>
<p>a rough agenda <a href="https://hackmd.io/QzlyvdORTzeWeBe78aDfXw?view">https://hackmd.io/QzlyvdORTzeWeBe78aDfXw?view</a></p>



<a name="218835403"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218835403" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218835403">(Dec 04 2020 at 13:58)</a>:</h4>
<p>I don't mind where; just making sure I know where to go :)</p>



<a name="218868373"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218868373" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218868373">(Dec 04 2020 at 17:56)</a>:</h4>
<p>don't know how to record a zoom meeting and I probably want to rewatch/reread parts of this meeting, so let's just go with zulip i guess <span aria-label="sweat smile" class="emoji emoji-1f605" role="img" title="sweat smile">:sweat_smile:</span></p>



<a name="218869137"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869137" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869137">(Dec 04 2020 at 18:00)</a>:</h4>
<p>well then, is everybody here?</p>



<a name="218869221"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869221" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869221">(Dec 04 2020 at 18:01)</a>:</h4>
<p><span aria-label="wave" class="emoji emoji-1f44b" role="img" title="wave">:wave:</span></p>



<a name="218869326"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869326" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869326">(Dec 04 2020 at 18:01)</a>:</h4>
<p><span aria-label="wave" class="emoji emoji-1f44b" role="img" title="wave">:wave:</span>  <span class="user-mention" data-user-id="116009">@nikomatsakis</span> <span class="user-mention" data-user-id="121053">@varkor</span></p>



<a name="218869402"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869402" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869402">(Dec 04 2020 at 18:02)</a>:</h4>
<p>I'm here :)</p>



<a name="218869620"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869620" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869620">(Dec 04 2020 at 18:03)</a>:</h4>
<p><span class="user-mention silent" data-user-id="216206">lcnr</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218825075">said</a>:</p>
<blockquote>
<p>a rough agenda <a href="https://hackmd.io/QzlyvdORTzeWeBe78aDfXw?view">https://hackmd.io/QzlyvdORTzeWeBe78aDfXw?view</a></p>
</blockquote>
<p>my idea for this meeting was to talk about the next steps after <code>min_const_generics</code> which pretty much boils down to always supplying the parent generics to anonymous constants</p>



<a name="218869803"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869803" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869803">(Dec 04 2020 at 18:04)</a>:</h4>
<p>to do this we need to prevent the cycle errors for things like</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">fn</span> <span class="nf">test</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">std</span>::<span class="n">mem</span>::<span class="n">size_of</span>::<span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">()]</span>: <span class="nc">Trait</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>



<a name="218869860"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869860" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869860">(Dec 04 2020 at 18:04)</a>:</h4>
<p>if we normalize constants at the end of <code>predicates_of</code> we have to typeck that anonymous constant</p>



<a name="218869915"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218869915" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218869915">(Dec 04 2020 at 18:05)</a>:</h4>
<p>which requires <code>predicates_of</code> of the parent, causing a cycle</p>



<a name="218870001"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870001" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870001">(Dec 04 2020 at 18:05)</a>:</h4>
<p>we currently circumvent this issue by using <code>feature(lazy_normalization_consts)</code></p>



<a name="218870206"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870206" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870206">(Dec 04 2020 at 18:07)</a>:</h4>
<p>do you remember what that feature does?</p>



<a name="218870246"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870246" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870246">(Dec 04 2020 at 18:07)</a>:</h4>
<p>I didn't know we had a special lazy norm feature gate just for constants</p>



<a name="218870265"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870265" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870265">(Dec 04 2020 at 18:07)</a>:</h4>
<p>it's active by default when using <code>feature(const_generics)</code></p>



<a name="218870570"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870570" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870570">(Dec 04 2020 at 18:10)</a>:</h4>
<p>Am I right in assuming that in <code>fn test&lt;T, U&gt;() where [u8; 1 + std::mem::size_of::&lt;T&gt;()]: Trait {}</code> the anonymous constant has two generic parameters, which, always get <code>T, U</code> passed when working with that constant</p>



<a name="218870586"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870586" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870586">(Dec 04 2020 at 18:10)</a>:</h4>
<p>yeah</p>



<a name="218870598"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870598" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870598">(Dec 04 2020 at 18:10)</a>:</h4>
<p>that's one of the big issues here</p>



<a name="218870637"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870637" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870637">(Dec 04 2020 at 18:11)</a>:</h4>
<p>for (<a href="https://github.com/rust-lang/rust/pull/79635/files#diff-34f61ce1f1f9e212f9d8abdebf4acff2f3edfa9a72827ec8f468fc5ad00ecd5d">https://github.com/rust-lang/rust/pull/79635/files#diff-34f61ce1f1f9e212f9d8abdebf4acff2f3edfa9a72827ec8f468fc5ad00ecd5d</a>)</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#![feature(const_generics, const_evaluatable_checked)]</span><span class="w"></span>
<span class="cp">#![allow(incomplete_features)]</span><span class="w"></span>

<span class="c1">// `N + 1` also depends on `T` here even if it doesn't use it.</span>
<span class="k">fn</span> <span class="nf">q</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="p">(</span><span class="n">_</span>: <span class="nc">T</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">todo</span><span class="o">!</span><span class="p">()</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">supplier</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span>-&gt; <span class="nc">T</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">todo</span><span class="o">!</span><span class="p">()</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">catch_me</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span>: <span class="nb">Default</span> <span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">supplier</span><span class="p">();</span><span class="w"></span>
<span class="w">    </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">q</span>::<span class="o">&lt;</span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="n">N</span><span class="o">&gt;</span><span class="p">(</span><span class="n">x</span><span class="p">);</span><span class="w"> </span><span class="c1">//~ ERROR mismatched types</span>
<span class="p">}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">catch_me</span>::<span class="o">&lt;</span><span class="mi">3</span><span class="o">&gt;</span><span class="p">();</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="218870849"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870849" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870849">(Dec 04 2020 at 18:12)</a>:</h4>
<p>Can we "just" use polymorphization to ask the constant which generic parameters it actually needs?</p>



<a name="218870904"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870904" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870904">(Dec 04 2020 at 18:12)</a>:</h4>
<p>pretty much, my idea is to use <code>const_evaluatable_checked</code> and look at the <code>AbstractConst</code></p>



<a name="218870975"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870975" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870975">(Dec 04 2020 at 18:13)</a>:</h4>
<p>this requires us to typeck the anonymous constant though</p>



<a name="218870981"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218870981" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218870981">(Dec 04 2020 at 18:13)</a>:</h4>
<p>oh, but isn't AbstractConst just limited to a certain subset of possible constant bodies?</p>



<a name="218871013"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871013" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871013">(Dec 04 2020 at 18:13)</a>:</h4>
<p>yeah, and for concrete ones we can just ignore all substs</p>



<a name="218871114"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871114" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871114">(Dec 04 2020 at 18:14)</a>:</h4>
<p>sure, but what if the entire thing is ... OH haha, if there is one generic parameter used anywhere it needs to be <code>AbstractConst</code>able <em>anyway</em></p>



<a name="218871120"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871120" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871120">(Dec 04 2020 at 18:14)</a>:</h4>
<p>so my idea is that an anon const is either:</p>
<ul>
<li>concrete, in which case we don't build an <code>AbstractConst</code> and are able to ignore all substs</li>
</ul>



<a name="218871163"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871163" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871163">(Dec 04 2020 at 18:14)</a>:</h4>
<ul>
<li>generc, in which case we error if we can't build an <code>AbstractConst</code> and ignore the substs not mentioned by that</li>
</ul>



<a name="218871227"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871227" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871227">(Dec 04 2020 at 18:15)</a>:</h4>
<p>I haven't been keeping up with <code>const_evaluatable_checked</code>: what is that going to produce in this case?</p>



<a name="218871272"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871272" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871272">(Dec 04 2020 at 18:15)</a>:</h4>
<p><code>AbstractConst</code> are a simplified representation of the mir of a constant</p>



<a name="218871305"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871305" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871305">(Dec 04 2020 at 18:15)</a>:</h4>
<p>which we use to unify two unevaluated consts</p>



<a name="218871371"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871371" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871371">(Dec 04 2020 at 18:16)</a>:</h4>
<p>Right, so they can contain generic parameters.</p>



<a name="218871377"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871377" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871377">(Dec 04 2020 at 18:16)</a>:</h4>
<p>yeah</p>



<a name="218871379"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871379" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871379">(Dec 04 2020 at 18:16)</a>:</h4>
<p>basically <code>N + 1 + 2</code> becomes <code>Add(Add(N, 1), 2)</code> (very simplified dummy example. The representation is more complex, but logically, that's it)</p>



<a name="218871493"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871493" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871493">(Dec 04 2020 at 18:17)</a>:</h4>
<p>(we could use "simple" polymorphization based on <code>mir_const</code> as well but that doesn't really matter in the end)</p>



<a name="218871494"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871494" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871494">(Dec 04 2020 at 18:17)</a>:</h4>
<p>So you build an <code>AbstractConst</code>, then walk through it, checking which parameters are actually used?</p>



<a name="218871504"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871504" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871504">(Dec 04 2020 at 18:17)</a>:</h4>
<p>yeah</p>



<a name="218871574"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871574" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871574">(Dec 04 2020 at 18:18)</a>:</h4>
<p>the issue is that building an <code>AbstractConst</code> requires <code>mir_const</code></p>



<a name="218871603"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871603" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871603">(Dec 04 2020 at 18:18)</a>:</h4>
<p>which requires <code>typeck</code></p>



<a name="218871622"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871622" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871622">(Dec 04 2020 at 18:18)</a>:</h4>
<p>which means that it would cause cycle errors inside of where clauses</p>



<a name="218871646"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871646" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871646">(Dec 04 2020 at 18:18)</a>:</h4>
<p>so we can only do this outside of <code>predicates_of</code></p>



<a name="218871654"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871654" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871654">(Dec 04 2020 at 18:18)</a>:</h4>
<p>uh... I don't know too much about where clauses, why does it cause a cycle?</p>



<a name="218871700"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871700" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871700">(Dec 04 2020 at 18:19)</a>:</h4>
<p>does it cause cycles if the generic parameters are actually used?</p>



<a name="218871716"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871716" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871716">(Dec 04 2020 at 18:19)</a>:</h4>
<p>but not if they are not used?</p>



<a name="218871762"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871762" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871762">(Dec 04 2020 at 18:19)</a>:</h4>
<p>in both cases</p>



<a name="218871853"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871853" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871853">(Dec 04 2020 at 18:20)</a>:</h4>
<p>when typechecking a body we need to know any additional predicates we can assume to be true</p>



<a name="218871858"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871858" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871858">(Dec 04 2020 at 18:20)</a>:</h4>
<p>the <code>caller_bounds</code></p>



<a name="218871874"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871874" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871874">(Dec 04 2020 at 18:20)</a>:</h4>
<p>so that if we have a predicate <code>T: Trait</code></p>



<a name="218871898"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871898" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871898">(Dec 04 2020 at 18:20)</a>:</h4>
<p>we can use <code>[u8; &lt;T as Trait&gt;::ASSOC]</code></p>



<a name="218871957"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871957" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871957">(Dec 04 2020 at 18:21)</a>:</h4>
<p>as anonymous constants inherit the generic environment of their parent</p>



<a name="218871971"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871971" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871971">(Dec 04 2020 at 18:21)</a>:</h4>
<p>ah... and that bound may be in a where bound, so we need to look at the where bounds...</p>



<a name="218871981"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218871981" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218871981">(Dec 04 2020 at 18:21)</a>:</h4>
<p>yeah</p>



<a name="218872071"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872071" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872071">(Dec 04 2020 at 18:22)</a>:</h4>
<p>ok, this is probably undoable, but before we continue: can we "just" copy all the where bounds onto the constant, but skip the where bounds that use the constant?</p>



<a name="218872085"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872085" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872085">(Dec 04 2020 at 18:22)</a>:</h4>
<p>These cycle errors may be genuine, right? I'm trying to think of an example...</p>



<a name="218872127"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872127" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872127">(Dec 04 2020 at 18:22)</a>:</h4>
<p><span class="user-mention silent" data-user-id="121053">varkor</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872085">said</a>:</p>
<blockquote>
<p>These cycle errors may be genuine, right? I'm trying to think of an example...</p>
</blockquote>
<p>somewhat</p>



<a name="218872145"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872145" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872145">(Dec 04 2020 at 18:22)</a>:</h4>
<p>will come back to exactly that later <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span></p>



<a name="218872192"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872192" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872192">(Dec 04 2020 at 18:23)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872071">said</a>:</p>
<blockquote>
<p>ok, this is probably undoable, but before we continue: can we "just" copy all the where bounds onto the constant, but skip the where bounds that use the constant?</p>
</blockquote>
<p>this is roughly what i want to do</p>



<a name="218872263"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872263" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872263">(Dec 04 2020 at 18:23)</a>:</h4>
<p>i've written <a href="https://github.com/lcnr/rust/pull/3">https://github.com/lcnr/rust/pull/3</a></p>



<a name="218872322"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872322" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872322">(Dec 04 2020 at 18:24)</a>:</h4>
<p>which instead of full lazy normalization only skips normalization while inside of <code>predicates_of</code></p>



<a name="218872361"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872361" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872361">(Dec 04 2020 at 18:24)</a>:</h4>
<p>and it seems to work</p>



<a name="218872533"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872533" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872533">(Dec 04 2020 at 18:25)</a>:</h4>
<p>does someone know of another reason why we want to use <code>lazy_normalization_consts</code></p>



<a name="218872682"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872682" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872682">(Dec 04 2020 at 18:26)</a>:</h4>
<p>if it's only to prevent cycles in some queries (i know of <code>predicates_of</code> and <code>type_of</code>) my approach looks really good to me</p>



<a name="218872692"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872692" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872692">(Dec 04 2020 at 18:26)</a>:</h4>
<p>^ <span class="user-mention" data-user-id="116009">@nikomatsakis</span></p>



<a name="218872699"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872699" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872699">(Dec 04 2020 at 18:26)</a>:</h4>
<p>I... am so amazed by that PR (so simple, but so wow)...</p>



<a name="218872734"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872734" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872734">(Dec 04 2020 at 18:27)</a>:</h4>
<p><span class="user-mention silent" data-user-id="121053">varkor</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872085">said</a>:</p>
<blockquote>
<p>These cycle errors may be genuine, right? I'm trying to think of an example...</p>
</blockquote>
<p>I guess any potential genuine cycle would lead to this bound removal simply failing (though maybe it'd require performing recursively, if one constant depending on another constant, which depended back on the original constant), so it should be okay.</p>



<a name="218872789"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872789" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872789">(Dec 04 2020 at 18:27)</a>:</h4>
<p><span class="user-mention" data-user-id="121053">@varkor</span> so an example here is <a href="https://github.com/rust-lang/rust/issues/79356">#79356</a></p>



<a name="218872869"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872869" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872869">(Dec 04 2020 at 18:28)</a>:</h4>
<p><span class="user-mention silent" data-user-id="216206">lcnr</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872533">said</a>:</p>
<blockquote>
<p>does someone know of another reason why we want to use <code>lazy_normalization_consts</code></p>
</blockquote>
<p><span class="user-mention" data-user-id="119009">@eddyb</span> would be the person I'd ask :)</p>



<a name="218872925"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872925" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872925">(Dec 04 2020 at 18:28)</a>:</h4>
<p>here a <code>[u8; unevaluated]: Sized</code> is a where clauses</p>



<a name="218872978"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872978" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872978">(Dec 04 2020 at 18:29)</a>:</h4>
<p>and while typechecking the unevaluated constant, we want to prove <code>[u8; other_unevaluated]: Sized</code></p>



<a name="218872984"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872984" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218872984">(Dec 04 2020 at 18:29)</a>:</h4>
<p>This should succeed in practice, though?</p>



<a name="218873012"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873012" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873012">(Dec 04 2020 at 18:29)</a>:</h4>
<p>if we ignore the where clause</p>



<a name="218873016"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873016" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873016">(Dec 04 2020 at 18:29)</a>:</h4>
<p>yes</p>



<a name="218873024"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873024" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873024">(Dec 04 2020 at 18:29)</a>:</h4>
<p>but we don't rn so this breaks</p>



<a name="218873027"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873027" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873027">(Dec 04 2020 at 18:29)</a>:</h4>
<p>Because there are no parameters. But does this not succeed under your fix?</p>



<a name="218873062"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873062" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873062">(Dec 04 2020 at 18:29)</a>:</h4>
<p>you mean <a href="https://github.com/lcnr/rust/pull/3">https://github.com/lcnr/rust/pull/3</a>?</p>



<a name="218873081"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873081" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873081">(Dec 04 2020 at 18:29)</a>:</h4>
<p>Yeah</p>



<a name="218873096"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873096" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873096">(Dec 04 2020 at 18:29)</a>:</h4>
<p>no</p>



<a name="218873180"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873180" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873180">(Dec 04 2020 at 18:30)</a>:</h4>
<p>the cycle here is caused by trying to unify the two unevaluated consts</p>



<a name="218873197"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873197" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873197">(Dec 04 2020 at 18:30)</a>:</h4>
<p>one of which we are currently typechecking</p>



<a name="218873227"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873227" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873227">(Dec 04 2020 at 18:30)</a>:</h4>
<p>and to unify two unevaluated constants we try to evaluate them</p>



<a name="218873247"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873247" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873247">(Dec 04 2020 at 18:30)</a>:</h4>
<p>which requires us to again typecheck them</p>



<a name="218873286"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873286" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873286">(Dec 04 2020 at 18:31)</a>:</h4>
<p>so we successfully evaluate <code>predicates_of</code></p>



<a name="218873306"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873306" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873306">(Dec 04 2020 at 18:31)</a>:</h4>
<p>and then fail during <code>typeck(outer_anon_const)</code></p>



<a name="218873612"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873612" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873612">(Dec 04 2020 at 18:33)</a>:</h4>
<p>Just trying to get the control flow straight in my head.</p>



<a name="218873954"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873954" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873954">(Dec 04 2020 at 18:36)</a>:</h4>
<p>Why doesn't <code>[u8; X]</code> always satisfy <code>Sized</code>, for any <code>X</code>? Surely it doesn't need to evaluate at any point?</p>



<a name="218873972"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218873972" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218873972">(Dec 04 2020 at 18:36)</a>:</h4>
<p>it does</p>



<a name="218874002"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874002" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874002">(Dec 04 2020 at 18:36)</a>:</h4>
<p>but we prioritize candidates from the param env</p>



<a name="218874034"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874034" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874034">(Dec 04 2020 at 18:36)</a>:</h4>
<p>over builtin ones</p>



<a name="218874070"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874070" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874070">(Dec 04 2020 at 18:37)</a>:</h4>
<p>so we still end up with first trying to match the explicit sized bound</p>



<a name="218874132"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874132" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874132">(Dec 04 2020 at 18:37)</a>:</h4>
<p>and if that one failed we would have tried the builtin bound which would succeed</p>



<a name="218874360"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874360" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874360">(Dec 04 2020 at 18:39)</a>:</h4>
<p>Is this an open problem then, or did you also have an idea for addressing this issue?</p>



<a name="218874373"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874373" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874373">(Dec 04 2020 at 18:39)</a>:</h4>
<p><a href="https://hackmd.io/QzlyvdORTzeWeBe78aDfXw#Recursive-dependencies-of-constants-in-the-param-env">https://hackmd.io/QzlyvdORTzeWeBe78aDfXw#Recursive-dependencies-of-constants-in-the-param-env</a></p>



<a name="218874391"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874391" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874391">(Dec 04 2020 at 18:39)</a>:</h4>
<h3>Recursive dependencies of constants in the param env</h3>
<p>To deal with <a href="https://github.com/rust-lang/rust/issues/79356">https://github.com/rust-lang/rust/issues/79356</a> I think that we should be able to special case <code>param_env</code> or <code>predicates_of</code> of anon consts <code>ct</code><br>
in where-clauses to replace all constants which are syntactically after <code>ct</code> or <code>ct</code> itself with something like <code>ConstKind::Opaque(DefId, Substs)</code> which are only equal to themselves.</p>



<a name="218874402"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874402" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874402">(Dec 04 2020 at 18:39)</a>:</h4>
<p>Ah, I don't think I saw that part earlier.</p>



<a name="218874528"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874528" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874528">(Dec 04 2020 at 18:40)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218872071">said</a>:</p>
<blockquote>
<p>ok, this is probably undoable, but before we continue: can we "just" copy all the where bounds onto the constant, but skip the where bounds that use the constant?</p>
</blockquote>
<p>we can have cycles of length two, so we have to somehow break them</p>



<a name="218874565"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874565" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874565">(Dec 04 2020 at 18:40)</a>:</h4>
<p>meaning that my idea is to only keep where bounds which are "in front" of the one containing our anon const</p>



<a name="218874667"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874667" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874667">(Dec 04 2020 at 18:41)</a>:</h4>
<p>Is that going to change visible behaviour depending on the order of the bounds? Aren't bounds order-agnostic at the moment?</p>



<a name="218874689"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874689" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874689">(Dec 04 2020 at 18:41)</a>:</h4>
<p>(I mean in terms of type checking, not diagnostics.)</p>



<a name="218874695"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874695" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874695">(Dec 04 2020 at 18:41)</a>:</h4>
<p>yeah, it would</p>



<a name="218874781"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874781" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874781">(Dec 04 2020 at 18:42)</a>:</h4>
<p>we could make all consts in the where bounds at the same level opaque</p>



<a name="218874819"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874819" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874819">(Dec 04 2020 at 18:42)</a>:</h4>
<p>which doesn't allow as much but would also fix this</p>



<a name="218874886"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874886" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874886">(Dec 04 2020 at 18:43)</a>:</h4>
<p>This sounds like exactly the sort of thing chalk was designed for :)</p>



<a name="218874910"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218874910" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218874910">(Dec 04 2020 at 18:43)</a>:</h4>
<p>Hmm</p>



<a name="218875523"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875523" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875523">(Dec 04 2020 at 18:48)</a>:</h4>
<p>I think I'll need to look at the code in a bit more detail to understand exactly what's going on with this example, but seems tricky.</p>



<a name="218875597"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875597" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875597">(Dec 04 2020 at 18:49)</a>:</h4>
<p>Do you know the answer to "Either by adding a new variant like <code>TyKind::Discarded</code> or just setting it[the unused substs] to <code>()</code> (does that work? This would result in a potentially inconsistent <code>param_env</code>, but that's probably already the case with <code>trivial_bounds</code> so <span aria-label="shrug" class="emoji emoji-1f937" role="img" title="shrug">:shrug:</span>)."?</p>



<a name="218875739"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875739" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875739">(Dec 04 2020 at 18:50)</a>:</h4>
<p>for the following</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">fn</span> <span class="nf">foo</span><span class="o">&lt;</span><span class="n">T</span>: <span class="nb">Iterator</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span>-&gt; <span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">2</span><span class="p">]</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>



<a name="218875771"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875771" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875771">(Dec 04 2020 at 18:50)</a>:</h4>
<p>are there any known issues if we set <code>T</code> to <code>()</code> for the anonymous constant</p>



<a name="218875844"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875844" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875844">(Dec 04 2020 at 18:51)</a>:</h4>
<p>You mean setting the substs in <code>AbstractConst</code> or elsewhere?</p>



<a name="218875871"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875871" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875871">(Dec 04 2020 at 18:51)</a>:</h4>
<p>the substs for the <code>ConstKind::Unevaluated</code></p>



<a name="218875970"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218875970" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218875970">(Dec 04 2020 at 18:52)</a>:</h4>
<p><code>1 + 2</code> is <code>ConstKind::Unevaluated { def: ..., substs: [T], promoted: None }</code> rn</p>



<a name="218876099"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876099" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876099">(Dec 04 2020 at 18:53)</a>:</h4>
<p>I have no idea what would happen if you did that :P<br>
I was wondering whether it would be possible for each <code>Unevaluated</code> to know how many parameters it's using, and then <code>substs</code> only contains those parameters, instead of containing dummy values.</p>



<a name="218876146"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876146" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876146">(Dec 04 2020 at 18:53)</a>:</h4>
<p>that's hard i think <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span></p>



<a name="218876228"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876228" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876228">(Dec 04 2020 at 18:54)</a>:</h4>
<p>esp because unevaluated consts start out with needing all substs</p>



<a name="218876246"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876246" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876246">(Dec 04 2020 at 18:54)</a>:</h4>
<p>Yeah, I could believe that. Probably quite a lot of bookkeeping.</p>



<a name="218876268"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876268" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876268">(Dec 04 2020 at 18:54)</a>:</h4>
<p>because we can't always construct the <code>AbstractConst</code> eagerly</p>



<a name="218876273"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876273" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876273">(Dec 04 2020 at 18:54)</a>:</h4>
<p>because cycles</p>



<a name="218876276"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876276" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876276">(Dec 04 2020 at 18:54)</a>:</h4>
<p>Right</p>



<a name="218876351"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876351" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876351">(Dec 04 2020 at 18:55)</a>:</h4>
<p>My naïve guess would be that <code>()</code> <em>should</em> work... but at the same time making an explicit variant instead seems more readable.</p>



<a name="218876443"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876443" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876443">(Dec 04 2020 at 18:56)</a>:</h4>
<p>But, we'd probably just need to make that change in one place, right, so maybe it's not so bad...</p>



<a name="218876483"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876483" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876483">(Dec 04 2020 at 18:56)</a>:</h4>
<p>(I.e. after constructing the <code>AbstractConst</code>.)</p>



<a name="218876540"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876540" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876540">(Dec 04 2020 at 18:57)</a>:</h4>
<p>Considering it's not using that parameter for anything, I don't see what <em>would</em> go wrong :P</p>



<a name="218876570"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876570" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876570">(Dec 04 2020 at 18:57)</a>:</h4>
<p>my thinking is that the parameter is in the param_env</p>



<a name="218876641"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876641" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876641">(Dec 04 2020 at 18:57)</a>:</h4>
<p>so yeah, I can't think of anything specific either</p>



<a name="218876663"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876663" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876663">(Dec 04 2020 at 18:57)</a>:</h4>
<p>but it does seem a bit sketchy</p>



<a name="218876755"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876755" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876755">(Dec 04 2020 at 18:58)</a>:</h4>
<p>It does seem worth trying as an experiment.</p>



<a name="218876915"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876915" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876915">(Dec 04 2020 at 18:59)</a>:</h4>
<p>so it seems that unless niko or eddy have any concerns we're going to end up throwing out <code>lazy_normalization_consts</code> <span aria-label="thinking" class="emoji emoji-1f914" role="img" title="thinking">:thinking:</span></p>



<a name="218876959"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218876959" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218876959">(Dec 04 2020 at 19:00)</a>:</h4>
<p>which does make me a bit sad tbh</p>



<a name="218877274"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877274" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877274">(Dec 04 2020 at 19:02)</a>:</h4>
<p>Mhm, I'd very much like to hear their thoughts.</p>



<a name="218877532"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877532" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877532">(Dec 04 2020 at 19:04)</a>:</h4>
<p>I haven't been keeping up with chalk integration recently; I wonder where they are with respect to const generics. There was some support last time I looked, if I remember correctly.</p>



<a name="218877572"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877572" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877572">(Dec 04 2020 at 19:04)</a>:</h4>
<p>from what i can tell the support is still fairly incomplete</p>



<a name="218877640"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877640" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877640">(Dec 04 2020 at 19:05)</a>:</h4>
<p>The little hacks that are necessary with the current type system are crying out for a more declarative constraint solving approach.</p>



<a name="218877647"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877647" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877647">(Dec 04 2020 at 19:05)</a>:</h4>
<p>i think they tried to add unevaluated constants but it looked like life got in the way there</p>



<a name="218877655"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877655" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877655">(Dec 04 2020 at 19:05)</a>:</h4>
<p>so the PR didn't land</p>



<a name="218877671"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877671" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877671">(Dec 04 2020 at 19:06)</a>:</h4>
<p>Ah, okay</p>



<a name="218877740"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877740" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877740">(Dec 04 2020 at 19:06)</a>:</h4>
<p>though some of these hacks are also there after we switch to chalk i think</p>



<a name="218877756"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877756" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877756">(Dec 04 2020 at 19:06)</a>:</h4>
<p>Which ones are you thinking of?</p>



<a name="218877782"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877782" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877782">(Dec 04 2020 at 19:06)</a>:</h4>
<p>typechecking stuff which is explicitly mention in it's own param env</p>



<a name="218877806"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877806" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877806">(Dec 04 2020 at 19:07)</a>:</h4>
<p><a href="https://github.com/rust-lang/rust/issues/79356">#79356</a></p>



<a name="218877842"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877842" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877842">(Dec 04 2020 at 19:07)</a>:</h4>
<p>i don't think chalk is able to handle that without some explicit changes</p>



<a name="218877849"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218877849" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218877849">(Dec 04 2020 at 19:07)</a>:</h4>
<p>That was exactly the one I was hoping chalk <em>would</em> be able to deal with.</p>



<a name="218878003"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878003" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878003">(Dec 04 2020 at 19:08)</a>:</h4>
<p>I need to catch up with everything that's been going on, and get a better high-level understanding of the state of everything... other things just keep getting in the way <span aria-label="weary" class="emoji emoji-1f629" role="img" title="weary">:weary:</span></p>



<a name="218878029"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878029" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878029">(Dec 04 2020 at 19:08)</a>:</h4>
<p>i don't know enough about chalk, but it does seem to me like this isn't really part of the type system anymore <span aria-label="sweat smile" class="emoji emoji-1f605" role="img" title="sweat smile">:sweat_smile:</span></p>



<a name="218878058"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878058" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878058">(Dec 04 2020 at 19:09)</a>:</h4>
<p>Cycle errors seem like type system problems to me :P</p>



<a name="218878075"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878075" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878075">(Dec 04 2020 at 19:09)</a>:</h4>
<p>well, it's a query problem</p>



<a name="218878094"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878094" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878094">(Dec 04 2020 at 19:09)</a>:</h4>
<p>not a type problem</p>



<a name="218878222"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878222" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878222">(Dec 04 2020 at 19:10)</a>:</h4>
<p>we have cycles in the type system</p>



<a name="218878250"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878250" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878250">(Dec 04 2020 at 19:10)</a>:</h4>
<p>I guess I was counting it as a type system problem because it happened during type checking :P</p>



<a name="218878257"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878257" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> varkor <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878257">(Dec 04 2020 at 19:10)</a>:</h4>
<p>I'm afraid I have to run off (i.e. switch windows) to another meeting in five minutes. Thanks for hosting this <span class="user-mention" data-user-id="216206">@lcnr</span>! That demo PR looks very encouraging and the other ideas definitely seem plausible to me ^_^</p>



<a name="218878310"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878310" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878310">(Dec 04 2020 at 19:11)</a>:</h4>
<p>my pleasure <span aria-label="thumbs up" class="emoji emoji-1f44d" role="img" title="thumbs up">:thumbs_up:</span> thanks for taking the time to talk this through with me you two</p>



<a name="218878384"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/218878384" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#218878384">(Dec 04 2020 at 19:12)</a>:</h4>
<p>So.. I guess just assign the PR to niko and eddyb and point to this discussion?</p>



<a name="219119107"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/219119107" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#219119107">(Dec 07 2020 at 18:34)</a>:</h4>
<p>it's annoying having to explicitly normalize everywhere but it doesn't look like I can avoid this</p>



<a name="219119140"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/219119140" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#219119140">(Dec 07 2020 at 18:34)</a>:</h4>
<p>will still take a while until that PR feels ready to me</p>



<a name="219119543"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/219119543" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#219119543">(Dec 07 2020 at 18:37)</a>:</h4>
<p>could it be that this stuff just <em>has</em> to be hard no matter what we do <span aria-label="cry" class="emoji emoji-1f622" role="img" title="cry">:cry:</span></p>



<a name="221242936"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221242936" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221242936">(Dec 30 2020 at 20:15)</a>:</h4>
<p>we also need lazy norm for const projections, don't we?</p>



<a name="221243190"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243190" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243190">(Dec 30 2020 at 20:18)</a>:</h4>
<p>like trying to relate <code>?0 + ?2</code> with <code>?1 + ?2</code> may succeed if <code>?0</code> and <code>?1</code> are equal which we can't really express without lazy norm</p>



<a name="221243203"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243203" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243203">(Dec 30 2020 at 20:18)</a>:</h4>
<p>i think</p>



<a name="221243278"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243278" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243278">(Dec 30 2020 at 20:19)</a>:</h4>
<p>hmm... is that really different from relating <code>?0</code> with <code>?1</code> directly?</p>



<a name="221243301"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243301" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243301">(Dec 30 2020 at 20:19)</a>:</h4>
<p>we must not</p>



<a name="221243381"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243381" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243381">(Dec 30 2020 at 20:20)</a>:</h4>
<p>or much rather, projections may not be injective</p>



<a name="221243441"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/lazy_normalization_consts/near/221243441" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/lazy_normalization_consts.html#221243441">(Dec 30 2020 at 20:21)</a>:</h4>
<p>so we can't assume this in the general case</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>